\n",
" Si c'est votre première visite dans ce TP, lisez attentivement chacun des points détaillé après ce paragraphe.
\n",
" Si vous avez déjà commencer à travailler sur ce TP et que vous souhaiter vous déplacer rapidement dans une partie précise vous pouvez choisir la partie que vous souhaitez rejoindre ci-dessous.
\n",
" Menu de navigation
\n",
" \n",
"
\n",
"
\n",
" La technologie jupyter permet d'exécuter du code python par un simple clique sur Executer ci-dessus.
\n",
" Les morceaux de code de cette page sont interprétées case par case. Pour savoir quelle case a été interprétée avant une autre, il suffit de repérer le numéro devant la case.
\n",
" Une fois qu'une case a été interprétée (=exécutée), la page garde en mémoire les variables et fonctions lues
\n",
" La plateforme propose quelques outils de purge de la mémoire : \n",
"
\n",
" Pour ne pas perdre votre travail pensez à le sauvegarder régulièrement. Par défault, la sauvegarde par un clic sur la disquette en haut à gauche de page, ou par le racourci clavier classique ctrl+S\n",
" est une sauvegarde en local, sur le serveur de jupyter. Vous pouvez et devez très régulièrement sauvegarder votre travail sur votre support personnel de sauvegarde (clef USB, se l'envoyer par mail etc). Ce faisant vous disposerez d'un fichier .ipynb (IPYthon NoteBook) qu'il vous suffira de recharger pour avancer. Après le rechargement assurez vous que les fonctionnalités anciennement developpées et variables utilisées sont bien dans la mémoire de la page (en rééxecutant les cases, ou plus rapidement par Kernel > Restart & Run All.
A NOTER : vous pouvez travailler sur le tp (et tout autre fichier .ipynb) hors connexion en installant une version local du notebook de jupyter. Il faut que votre machine possède un interpreteur de python et que vous soyez connecter à internet.\n", "
pip install jupyterlabjupyter notebook\n",
" Menu de navigation
\n",
" \n",
"
\n",
"
Fan de la série télévisé des Monty python, Guido van Rossum, crée à la fin des années 80 un langage de programmation alors qu’il travaillait sur un autre. Il s’inspire de ce que les langages offrent de mieux à son époque et parvint à faire adopter\n", "ce langage à ses collègues de travail. Deux années après sa création, Python est rendu publique en open source. Ce langage a bénéficié de nombreuses avancées par de nombreux collaborateurs (comme la DARPA pour n’en cité qu’un) et a été entre autre pensé pour l’enseignement de l’informatique.
\n", "\n", "Comme tout bon langage de programmation, il est de prime abord une calculatrice sophistiquée.
\n", "\n", "Exéctuer la case suivante pour réaliser une simple addition.
" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "2+3" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Comme vous l'observez, le mot Out est apparu à gauche. En effet, nous avons demandé à notre langage, python, de réaliser l'opération $2+3$ ; sans plus. C'est Jupyter (la plateforme que nous utilisons ici) qui comprend que nous souhaitons réaliser une addition et la voir apparaitre. Comme jupyter est aussi gentil que python, il prend l'initiative de nous afficher la réponse. Nous allons revenir sur cette prise d'initiative (non mais oh !) mais explorons les différentes opérations que nous pouvons réaliser sur les nombres.
\n", "\n", "\n", "
+ | \n",
" pour l'addition | \n", "
- | \n",
" pour la soustraction | \n", "
* | \n",
" pour la multiplication | \n", "
/ | \n",
" pour la division à virgule flottante | \n", "
// | \n",
" pour la division entière (sans partie décimale) | \n", "
% | \n",
" pour le modulo (le reste de la division euclidienne) | \n", "
** | \n",
" pour la puissance | \n", "
2020-52020//52020/52020%52**5Comme tout logiciel de calcul, python réalise des erreurs d'approximation, parfois surprennante. Observer l'exécution de la case précédente.
" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Les erreurs d'arrondis sont très insignifiantes mais très courrantes en informatique (pas qu'en python). Il faut garder en tête que lorsque les programmes indiquent que le résultat est 0, il s'agit en fait d'une valeur approchée de ce nombre.
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Python gère très bien l'écriture scienfique (avec ses erreurs d'arrondis intrinsec à tous les langages). Exécuter la case suivante.
" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "1.1234e-2+0.001" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Réaliser les opérations suivantes :\n", "
" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Comme n'importe quelle calculatrice, nous souhaitons pouvoir utiliser des fonctions comme le cosinus, la racine carré, le logarithme etc. Pour pouvoir utiliser ces fonctionnalités dites avancées il faut les charger dans le programme. Autrement dis : pour calculer la racine carré de $2$, il faut écrire un programme de calcul de la racine carré. Fort heureusement d'autre s'en sont déjà occupé ! Le fait de charger cette fonction reviens à aller chercher le code d'autre programmeur et de simplement l'utiliser. Toutes les fonctions mathématiques dont nous pourrions avoir besoin sont rangé dans une bibliothèque : math (original). Exécuter la case suivante pour charger les fonctions de math.
Une fois chargée, voici ce que vous pouvez à présent faire:\n", "\n", "
| Mathématiques | \n", "Python | \n", "
|---|---|
| $|x|$ | \n", "abs(x) | \n",
"
| $\\sqrt{x}$ | \n", "sqrt(x) | \n",
"
| $e^x$ | \n", "exp(x) | \n",
"
| $ln(x)$ | \n", "log(x) | \n",
"
| $log(x)$ | \n", "log10(x) | \n",
"
| $cos(x)$ | \n", "cos(x) | \n",
"
| $sin(x)$ | \n", "sin(x) | \n",
"
| $tan(x)$ | \n", "tan(x) | \n",
"
| $\\pi$ | \n", "pi | \n",
"
| $e(=e^1)$ | \n", "e | \n",
"
| $x^y$ | \n", "pow(x, y) | \n",
"
| $n!$ | \n", "factorial(n) | \n",
"
Python peut faire bien mieux (et encore plus que ça) que ces opérations élémentaires. Le premier point important c'est que l'on peut stocker le résultat d'une opération dans une variable et utiliser cette variable pour d'autres opérations.
Pour utiliser une variable rien de plus simple : il faut la déclarer en la nommant et l'initialiser en lui attribuant une valeur. Il y a bien deux étapes pour jouer avec une variable : \n",
"
x0y, X0y, x0Y et X0Y sont différentes.=x=0 fera exister une variable x qui aura la valeur 0. On peut ensuite faire sur x toutes les opérations que l'on souhaite (celle que l'on a vu plus haut) avec des valeurs numériques ou d'autres variables (qui contiennent des valeurs numérique).\n",
"\n",
"\n",
"Pour afficher une ou plusieurs variables on utilise la fonction print (nous reviendrons sur la notion de fonction). Par exemple la commande print(x) affichera la valeur de la variable x (si elle existe dans le code ; une erreur sinon). De même print(x, y, 0, z) affichera la valeur de x, de y, le nombre 0 et la valeur de z.
Lisez attentivement le code suivant et anticiper la valeur de x. Vérfier votre résultat en exécutant les deux cases suivantes.
Lorsque nous réaliserons des codes un peu plus sophistiqué, il pourra être raisonnable de les commenter (pour comprendre ce qui nous est passé par la tête au moment de son ériture, ou si quelqu'u d'autre doit lire notre code).\n", "En python, il existe deux manière de faire un commentaires : \n", "
# pour que tout ce qui suit ce symbole soit ignoré, jusqu'à la fin de la ligne.''' pour que tout ce qui suit ces symboles soit ignoré jusqu'au prochain triple guillemets.\n",
" Menu de navigation
\n",
" \n",
"
\n",
"
Un proposition est un énoncé dont on peut dire sans ambiguïté qu'il est vrai ou qu'il est faux. En python le vrai et le faux sont représentés par le 1 ou plus proprement True (la majuscule est importante) pour vrai et le 0 ou plus proprement False pour Faux. Bien que cela n'ai pas vraiment de sens on peut additionner multiplier etc... les True et False avec des nombres. La variable False valant alors 0 et la variable True valant 1.
L'existence de True et False permet de réaliser, comme nous l'avons vu en cours, du calcul propositionnel. En python, il existe également les opérations de la logique, qui sont simplement la version anglophone de leur pendant français : \n",
"\n",
"
| Logique | \n", "Math | \n", "Python | \n", "
|---|---|---|
| et | \n", "$\\wedge$ | \n", "and | \n",
"
| ou | \n", "$\\vee$ | \n", "or | \n",
"
| non | \n", "$\\neg$ | \n", "not | \n",
"
Anticiper le résultat des affichages suivant et vérifier vos résultats en exécutant la case.
" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#1\n", "test = (True and False) \n", "print(test)\n", "\n", "#2\n", "test = (True or False) \n", "print(test)\n", "\n", "#3\n", "test = (not True or False) \n", "print(test)\n", "\n", "#4\n", "test = (not (True or False)) \n", "print(test)\n", "\n", "#5\n", "test = (not (True and not False)) \n", "print(test)\n", "\n", "#6\n", "test = (not(True and False) and (True and not False or (True and not(not False and True)))) \n", "print(test)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "On peut tester si des variables prennent des valeurs particulières ou sont plus grandes ou plus petites que ces dites valeurs. Elles sont toutes très instinctives comme sur les exemples suivants : \n", "
3*x-1<1/2*y renverra True si $3x-1$ est strictement inférieur à $\\dfrac{1}{2}y$ et False sinon.x**2>=(y**3%2020) renverra True si $x^2$ est supérieur ou égale au reste de la division euclidienne de $y^3$ par $2020$ et False sinon.= est déjà réservé en python et permet l'affectation d'une valeur à une variable. Pour tester une égalité, on utilise le double égale ==. Ainsi\n",
"x=0 affecte la valeur 0 à la variable x tandis que x==0 renverra True si x est nul et False sinon.\n",
"\n",
"Il y a aussi une petite simplification de code offerte par python. Le code not (x==0) s'écrit aussi x!=0.
Anticiper le résultat des affichages suivant et vérifier vos résultats en exécutant la case.
" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#Initialisation\n", "x = 1\n", "y = 10\n", "z = 100\n", "\n", "#1\n", "Test = (10*x>y)\n", "print(Test)\n", "\n", "#2\n", "Test = (10*x>=y)\n", "print(Test)\n", "\n", "#3\n", "Test = (10*x==y)\n", "print(Test)\n", "\n", "#4\n", "Test = (x+y+z%y==x)\n", "print(Test)\n", "\n", "#5\n", "Test = ((x+y+z)%y==x)\n", "print(Test)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Elles permettent d'exécuter un bout de code si une condition est satisfaite, un autre bout de code sinon.
\n",
"
\n", " si\n", "Dont les mots clef du python sontTestest vrai alors faire :
\n", " un bout de code
\n", " sinon faire :
\n", " un autre bout de code
\n", "
if (pour le si) et else (pour le sinon). Il faut aussi faire suivre le test par :.\n",
"ATTENTION : il est important que les bout de code soit tabulés comme dans l'exemple suivant.\n",
""
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"#Initialisation\n",
"x = 1\n",
"y = 10\n",
"z = 100\n",
"\n",
"#Exemple 1\n",
"if (x+y+z%y==x) :\n",
" print(x+y+z%y==x)\n",
" print(\"Le test est vrai\")\n",
"else :\n",
" print(x+y+z%y==x)\n",
" print(\"Le test est faux\")\n",
" \n",
"#Exemple 2\n",
"if ((x+y+z)%y==x) :\n",
" print((x+y+z)%y==x)\n",
" print(\"Le test est vrai\")\n",
"else :\n",
" print((x+y+z)%y==x)\n",
" print(\"Le test est faux\")\n",
" "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
" Menu de navigation
\n",
" \n",
"
\n",
"
La puissance de n'importe quel (bon) langage de programmation viens de ce que l'on appel des boucles. C'est à dire l'instruction qui demande de réaliser une ou plusieurs ligne de code tant qu'une certaine proposition n'est pas fausse. Le plus : l'ordinateur ne se plaindra pas si cette boucle dure mille ans !
\n", "\n", " Il existe deux type de boucle. Pour simplifier ce cours nous n'en présentons qu'une (la plus simple). Il sagit du while qui se traduit par tant que.\n",
"
\n",
"
\n", " Tant que\n", "Comme pour leTestest vrai alors faire :
\n", " un bout de code
\n", " sinon faire la suite\n", "
if, il faut faire suivre le test par : et placer le le bout de code dans une zone tabulée. Voici un exemple\n",
""
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"i=1\n",
"while(i<=5) :\n",
" print(i)\n",
" i=i+1"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Pour chacune des cases suivantes, indiquer ce qu'affichera le programme et vérifier en l'éxécutant.
" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "i=10\n", "while(i>=0) :\n", " print(i**2)\n", " i=i-2" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "scrolled": true }, "outputs": [], "source": [ "x=1\n", "y=0\n", "while(x!=y) :\n", " print(x, y)\n", " if(x>y) :\n", " y=y+2\n", " else : \n", " x=x+1\n", "print(x, y)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a=2\n", "b=-1\n", "while(a+b==0) : \n", " print(a+b)\n", "print(a+b)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a=1\n", "b=-1\n", "while(a+b==0) : \n", " print(a+b)\n", "print(a+b)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n",
" Menu de navigation
\n",
" \n",
"
\n",
"
Comme dans la vie de tous les jours pour les humains la base de numération canonique de python est la base 10. Dans cette partie nous allons nous intérésser à d'autre base. Cependant, comme python est gentil et que pour un ordinateur, le binaire, l'octal et l'héxadécimal sont usuelles, il existe des opération de conversion automatique.\n", "
0b. La fonction bin converti un nombre décimal en binaire.0o. La fonction oct converti un nombre décimal en octal.0x. La fonction hex converti un nombre décimal en hexadécimal.int converti un nombre décimal quelque soit sa base de départ (pourvu que le chiffre passé en paramètre possède le bon préfixe).Tout comme précédement, nous pouvons sur les bases $2$, $8$ et $16$ réaliser des opérations et des test en précisant bien à python laquelle de ces bases nous utilisons en indiquant le préfixe.\n", "
Avec ces informations, anticipez les résultats des opérations suivantes et vérifier les en exécutant la case.
" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#Initialisation+opérations\n", "x=0b1010+0x10\n", "y=0b1010+0o10\n", "z=0b1010+0b10\n", "\n", "#Affichage\n", "print(x, y, z)\n", "\n", "#1\n", "if(x==26) : \n", " print(\"x vaut 26\")\n", "else : \n", " print(\"x ne vaut pas 26\")\n", "\n", "#2\n", "if(y==0x18) : \n", " print(\"y vaut 18 en base 16\")\n", "else : \n", " print(\"y ne vaut pas 18 en base 16\")\n", " \n", "#3\n", "print(bin(z))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Là, les choses se compliquent : rien n'est automatisé SAUF pour revenir en décimale. Il s'agit encore une fois de la fonction int mais avec deux paramètres : \n",
"
int(0b1010) et int(\"1010\", 2) sont équivalents. 0, 1,...,9 puis comme pour l'héxadécimale a, b jusqu'à z (10 chiffres et 26 lettres soit une base maximale de 36).\n",
"\n",
"A présent l'objectif est d'écrire un programme qui transforme n'importe quelle nombre en décimale en un nombre en base b quelconque que nous supposerons inférieur à 36 pour pouvoir utiliser la fonction int pour vérfier notre calcul. Mais cette fonction prend des chiffres entre guillemets. Ce n'est pas autre chose qu'une chaine de caractère. Ainsi pour python 0 est le nombre $0$ mais \"0\" est une chaine de caractère, composé du seul caractère $0$. De même \"Salut ! Ca va les mathématiques\". Comme pour les nombres nous pouvons stocker les chaines de caractères dans des variables et comme pour les nombres nous pouvons réaliser quelques opérations. Nous n'en détaillons qu'une : la concaténation qui passe par l'opération +. Prenez garde : \n",
"
10+1 renvoie le nombre 11.\"10\"+\"1\" renvoie la chaine \"101\".\"10\"+1 est une erreur.Quelques petit plus : \n", "
str permet de transformer un nombre en chaine de caractère et la fonction int (encore) fait l'inverse !x on fait x[i].x (le nombre de caractère) est donné par len(x).Qu'affichera le code suivant ? Vérifiez votre résultat en exécutant la case.
" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x=1\n", "y=10\n", "z=str(x)+str(y)\n", "t=str(y)+str(x)\n", "u=int(z)+int(t)\n", "v=str(u)\n", "print(v[len(v)-1])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Comme pour les meilleurs films... nous avons déjà spoiler la fin (Daenerys meurt à la fin) ! Nous avons en effet déjà rencontré les fonctions en python : print, int, hex, sqrt etc. Pour définir une fonction on utilise le mot clef def suivit du nom de la fonction (qui doit respecter les même règles que les variables), puis les paramètres puis : puis le code de la fonction. Pour indiquer la valeur renvoyée par la fonction, on utilise le mot clef return qui intérompt l'appel de la fonction (donc une fonction s'intérompt si elle renvoie une valeur, soit si on arrive à la fin de ce qui la définie).
Voici un exemple de fonction. Que feront les appels de la case suivante. Vérifier vos résultats en éxécutant les cases.
" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def mystere(f, x) :\n", " if(x<=0) : \n", " return 0\n", " x=x**2\n", " return f(x)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x=-1\n", "print(mystere(log10, x))\n", "\n", "x=exp(2)\n", "print(mystere(log, x))\n", "\n", "x=121\n", "print(mystere(sqrt, x))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Dans la case suivante écrire la fonction ChangeBase(n, b) qui prend un entier n (que l'on supposera positif) et une base b (que l'on supposera strictement supérieur à $1$ et inférieur ou égale à $36$) et qui renvoie la chaine de caractère du nombre n en base b.
\n",
" Menu de navigation
\n",
" \n",
"
\n",
"
Dans la case suivante écrire la fonction ChangeBaseDec(x, b) qui prend un nombre décimale x et une base b (que l'on supposera strictement supérieur à $1$ et inférieur ou égale à $36$) et qui renvoie la chaine de caractère du nombre x en base b. On séparera la partie décimale de la partie entière par un point.
Dans la case suivante écrire la fonction ChangeBaseDecInv(x, b) qui prend un nombre décimale en base b, x (qui est une chaine de caractère) et la base b (que l'on supposera strictement supérieur à $1$ et inférieur ou égale à $36$) et qui renvoie le nombre décimale correspondant à l'écriture de x en base décimale.
\n",
" Menu de navigation
\n",
" \n",
"
\n",
"
Pour pouvoir réaliser des graphiques en python, nous avons besoin de spécifier des listes (de points). La fonction de base est la fonction range qui permet très rapidement d'énumeré des entiers (et non des nombres décimaux). Voici les trois utilisations possible : \n",
"
range(n) qui donne la liste des entiers de 0 à n-1. Par exemple range(10) donnera [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] range(a, b) qui donne la liste des entiers entre a et b-1. Par exemple range(3, 10) donnera [3, 4, 5, 6, 7, 8, 9] range(a, b, p) qui donne la liste des entiers entre a et b-1 par bond de p. Par exemple range(3, 10, 3) donnera [3, 6, 9] Donner la liste des entiers entre $2000$ et $2020$ qui sont dans la table de $5$.
" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Il est possible de créer des listes de nombres pas forcément entiers de la manière suivante : \n", "
\n",
" y=[fonction de x for x in valeur]\n",
"\n",
"Dans ce cas la liste y aura dans chacune de ses cases la valeur de f(x) pour les différentes valeurs prises par x. Voici des exemples :\n",
"\n",
" y=[x**2/10 for x in range(1, 10, 2)]\n",
"\n",
"alors \n",
"y=[0.1, 0.9, 2.5, 4.9, 8.1]\n",
"\n",
" z=[pow(abs(t), t/2 ) for t in range(-10, 10, 1)]\n",
"\n",
"alors \n",
"z=[1e-05, 5.080526342529086e-05, 0.000244140625, 0.001101937239093957, 0.004629629629629629, 0.01788854381999832, 0.0625, 0.19245008972987526, 0.5, 1.0, 1.0, 1.0, 2.0, 5.196152422706632, 16.0, 55.90169943749474, 216.0, 907.4926996951546, 4096.0, 19683.0]\n",
"Comme pour les fonctions, il faut définir la fenêtre de graphique. Par chance, d'autre s'en sont occupés. Chargeons cette fonctionnalité : exécuter la case suivante.
" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from matplotlib.pyplot import *" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Pour faire un graphique rien de plus simple ! On utilise la fonction plot qui prend au moins deux paramètres : \n",
"
grid(True) permet d'afficher une grille dans le graphique. Exemple : \n",
" plot(X, Y)
grid(True)plot, comme dans l'exemple suivant : \n",
" plot(X, Y, 'k')| Couleur | \n", "Code | \n", "
|---|---|
| Bleu | \n", "'b' | \n",
"
| Vert | \n", "'g' | \n",
"
| Rouge | \n", "'r' | \n",
"
| Cyan | \n", "'c' | \n",
"
| Magenta | \n", "'m' | \n",
"
| Jaune | \n", "'y' | \n",
"
| Noir | \n", "'k' | \n",
"
| Blanc | \n", "'w' | \n",
"
| Style | \n", "Code | \n", "
|---|---|
| Ligne continue (par défaut) | \n", "'-' | \n",
"
| Tiret | \n", "'--' | \n",
"
| Pointillé | \n", "':' | \n",
"
plot(X, Y, ':')
plot(X, Y, ':', 'r') est une erreur. On corrigera par\n",
" plot(X, Y, 'r:')
plot(X, Y) place par défaut des points (ceux de X et Y) et les relie par des traits (où d'autre style comme nous l'avons vu précédement). On peut changer le style des marques parmi ceux de la liste suivante : \n",
" | Marqueur | \n", "Code | \n", "
|---|---|
| Point (par défaut) | \n", "'.' | \n",
"
| Cercle | \n", "'o' | \n",
"
| Triangle vers le bas | \n", "'v' | \n",
"
| Triangle vers le haut | \n", "'^' | \n",
"
| Triangle vers la gauche | \n", "'<' | \n",
"
| Triangle vers la droite | \n", "'>' | \n",
"
| Carré | \n", "'s' | \n",
"
| Pentagone | \n", "'p' | \n",
"
| Etoile | \n", "'*' | \n",
"
| Plus | \n", "'+' | \n",
"
| Croix | \n", "'x' | \n",
"
| Losange | \n", "'d' | \n",
"
plot(X, Y, 'rd:')
plot la paramètre linewidth.\n",
" plot(X, Y, linewidth=5)
xlim et ylim qui prennent chacun deux paramètres : la plus grande et la plus petite valeur sur les axes respectifs.\n",
" plot(X, Y)
xlim(-1,1)
ylim(-10, 10)title\n",
" plot(X, Y)
title(\"Graphique de ma fonction\")plot différent). Dans ce cas, pour les disctinguer (en plus des couleurs), on peut légender les différentes courbes. Il y a pour cela deux choses à faire : \n",
" label dans plot.label. Pour cela on appel la fonction legend sans paramètre.plot(X, Y, label=\"Fonction 1\")
plot(X, Z, label=\"Fonction 2\")
legend()xlabel pour les abscisses et ylabel pour les ordonnées.\n",
" plot(X, Y)
xlabel(\"Abscisses\")
ylabel(\"Ordonnées\")Voici un exemple qui résume tout (dans les label a été placé du code $\\LaTeX$ qui une langage d'édition d'équation compris par Jupyter. N'y prétez pas attention, et admiez le résultat).
" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#Coordonnes des points\n", "X=[x/10 for x in range(10+1)]\n", "Y=[sqrt(x) for x in X]\n", "Z=[x**2 for x in X]\n", "\n", "#Dessin\n", "plot(X, Y, 'cx-', linewidth=1.5, label=\"$x\\mapsto \\sqrt{x}$\")\n", "plot(X, Z, 'm^--', label=\"$x\\mapsto x^2$\")\n", "plot(X, X, 'r*:', label=\"$x\\mapsto x$\")\n", "\n", "#Dimension de la fenêtre\n", "xlim(0, 1)\n", "ylim(0, 1)\n", "\n", "#Titre et légende\n", "title(\"Comparaison entre $x^2$ et $\\sqrt{x}$ sur $[0; 1]$\")\n", "xlabel(\"Abscisses\")\n", "ylabel(\"Ordonnées\")\n", "legend()\n", "\n", "#Quadrillage\n", "grid(True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "